diff --git a/user_guide/overview/appflow.html b/user_guide/overview/appflow.html
index 44f2021..affcd66 100644
--- a/user_guide/overview/appflow.html
+++ b/user_guide/overview/appflow.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>Code Igniter User Guide</title>
+<title>CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -22,7 +22,7 @@
 <meta http-equiv= 'pragma' content='no-cache' />
 <meta name='robots' content='all' />
 <meta name='author' content='Rick Ellis' />
-<meta name='description' content='Code Igniter User Guide' />
+<meta name='description' content='CodeIgniter User Guide' />
 
 </head>
 <body>
@@ -33,7 +33,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>Code Igniter User Guide Version 1.5.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 1.5.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -45,7 +45,7 @@
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
 <td id="breadcrumb">
-<a href="http://www.codeigniter.com/">Code Igniter Home</a> &nbsp;&#8250;&nbsp;
+<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
 <a href="../index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
 Appflow
 </td>
@@ -69,7 +69,7 @@
 
 
 <ol>
-<li>The index.php serves as the front controller, initializing the base resources needed to run Code Igniter.</li>
+<li>The index.php serves as the front controller, initializing the base resources needed to run CodeIgniter.</li>
 <li>The Router examines the HTTP request to determine what should be done with it.</li>
 <li>If a cache file exists, it is sent directly to the browser, bypassing the normal system execution.</li>
 <li>Security.  Before the application controller is loaded, the HTTP request and any user submitted data is filtered for security.</li>
@@ -87,14 +87,14 @@
 
 <div id="footer">
 <p>
-Previous Topic:&nbsp;&nbsp;<a href="features.html">Code Igniter Features</a>
+Previous Topic:&nbsp;&nbsp;<a href="features.html">CodeIgniter Features</a>
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 Next Topic:&nbsp;&nbsp;<a href="mvc.html">Model-View-Controller</a>
 <p>
 
-<p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
+<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
 </div>
 
 </body>
diff --git a/user_guide/overview/at_a_glance.html b/user_guide/overview/at_a_glance.html
index 2183d01..47362e0 100644
--- a/user_guide/overview/at_a_glance.html
+++ b/user_guide/overview/at_a_glance.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>Code Igniter User Guide</title>
+<title>CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -22,7 +22,7 @@
 <meta http-equiv= 'pragma' content='no-cache' />
 <meta name='robots' content='all' />
 <meta name='author' content='Rick Ellis' />
-<meta name='description' content='Code Igniter User Guide' />
+<meta name='description' content='CodeIgniter User Guide' />
 
 </head>
 <body>
@@ -33,7 +33,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>Code Igniter User Guide Version 1.5.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 1.5.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -45,9 +45,9 @@
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
 <td id="breadcrumb">
-<a href="http://www.codeigniter.com/">Code Igniter Home</a> &nbsp;&#8250;&nbsp;
+<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
 <a href="../index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
-What is Code Igniter?
+What is CodeIgniter?
 </td>
 <td id="searchbox"><form method="get" action="http://www.google.com/search"><input type="hidden" name="as_sitesearch" id="as_sitesearch" value="www.codeigniter.com/user_guide/" />Search User Guide&nbsp; <input type="text" class="input" style="width:200px;" name="q" id="q" size="31" maxlength="255" value="" />&nbsp;<input type="submit" class="submit" name="sa" value="Go" /></form></td>
 </tr>
@@ -60,63 +60,63 @@
 <!-- START CONTENT -->
 <div id="content">
 
-<h1>Code Igniter at a Glance</h1>
+<h1>CodeIgniter at a Glance</h1>
 
 
-<h2>Code Igniter is an Application Framework</h2>
+<h2>CodeIgniter is an Application Framework</h2>
 
-<p>Code Igniter is a toolkit for people who build web application using PHP.  Its goal is to enable you to develop projects much faster than you could if you were writing code
+<p>CodeIgniter is a toolkit for people who build web application using PHP.  Its goal is to enable you to develop projects much faster than you could if you were writing code
 from scratch, by providing a rich set of libraries for commonly needed tasks, as well as a simple interface and
-logical structure to access these libraries. Code Igniter lets you creatively focus on your project by
+logical structure to access these libraries. CodeIgniter lets you creatively focus on your project by
 minimizing the amount of code needed for a given task.</p>
 
-<h2>Code Igniter is Free</h2>
-<p>Code Igniter is licensed under an Apache/BSD-style open source license so you can use it however you please.
+<h2>CodeIgniter is Free</h2>
+<p>CodeIgniter is licensed under an Apache/BSD-style open source license so you can use it however you please.
 For more information please read the <a href="../license.html">license agreement</a>.</p>
 
 
-<h2>Code Igniter Runs on PHP 4</h2>
-<p>Code Igniter is written to be compatible with PHP 4.  Although we would have loved to take advantage of the better object handling
+<h2>CodeIgniter Runs on PHP 4</h2>
+<p>CodeIgniter is written to be compatible with PHP 4.  Although we would have loved to take advantage of the better object handling
 in PHP 5 since it would have simplified some things we had to find creative solutions for (looking your way, multiple inheritance),
 at the time of this writing PHP 5 is not in widespread use, which means we would be alienating most of our
 potential audience.  Major OS vendors like RedHat have yet to support PHP 5, and they are unlikely to do so until 2007, so
-we felt that it did not serve the best interests of the PHP community to write Code Igniter in PHP 5.</p>
+we felt that it did not serve the best interests of the PHP community to write CodeIgniter in PHP 5.</p>
 
-<p>Note:  Code Igniter will run on PHP 5.  It simply does not take advantage of any native features that are only available in that version.</p>
+<p>Note:  CodeIgniter will run on PHP 5.  It simply does not take advantage of any native features that are only available in that version.</p>
 
-<h2>Code Igniter is Light Weight</h2>
+<h2>CodeIgniter is Light Weight</h2>
 <p>Truly light weight.  The core system requires only a few very small libraries. This is in stark contrast to many frameworks that require significantly more resources.
 Additional libraries are loaded dynamically upon request, based on your needs for a given process, so the base system
 is very lean and quite fast.
 </p>
 
-<h2>Code Igniter is Fast</h2>
-<p>Really fast. We challenge you to find a framework that has better performance then Code Igniter.</p>
+<h2>CodeIgniter is Fast</h2>
+<p>Really fast. We challenge you to find a framework that has better performance then CodeIgniter.</p>
 
 
-<h2>Code Igniter Uses M-V-C</h2>
-<p>Code Igniter uses the Model-View-Controller approach, which allows great separation between logic and presentation.
+<h2>CodeIgniter Uses M-V-C</h2>
+<p>CodeIgniter uses the Model-View-Controller approach, which allows great separation between logic and presentation.
 This is particularly good for projects in which designers are working with your template files, as the code these file contain will be minimized. We describe MVC in more detail on its own page.</p>
 
-<h2>Code Igniter Generates Clean URLs</h2>
-<p>The URLs generated by Code Igniter are clean and search-engine friendly.  Rather than using the standard "query string"
-approach to URLs that is synonymous with dynamic systems, Code Igniter uses a segment-based approach:</p>
+<h2>CodeIgniter Generates Clean URLs</h2>
+<p>The URLs generated by CodeIgniter are clean and search-engine friendly.  Rather than using the standard "query string"
+approach to URLs that is synonymous with dynamic systems, CodeIgniter uses a segment-based approach:</p>
 
 <code>www.your-site.com/<var>news</var>/<dfn>article</dfn>/<samp>345</samp></code>
 
 <p>Note: By default the index.php file is included in the URL but it can be removed using a simple .htaccess file.</p>
 
-<h2>Code Igniter Packs a Punch</h2>
-<p>Code Igniter comes with  full-range of libraries that enable the most commonly needed web development tasks,
+<h2>CodeIgniter Packs a Punch</h2>
+<p>CodeIgniter comes with  full-range of libraries that enable the most commonly needed web development tasks,
 like accessing a database, sending email, validating form data, maintaining sessions, manipulating images, working with XML-RPC data and 
 much more.</p>
 
-<h2>Code Igniter is Extensible</h2>
+<h2>CodeIgniter is Extensible</h2>
 <p>The system can be easily extended through the use of plugins and helper libraries, or through class extensions or system hooks.</p>
 
 
-<h2>Code Igniter Does Not Require a Template Engine</h2>
-<p>Although Code Igniter <em>does</em> come with a simple template parser that can be optionally used, it does not force you to use one.
+<h2>CodeIgniter Does Not Require a Template Engine</h2>
+<p>Although CodeIgniter <em>does</em> come with a simple template parser that can be optionally used, it does not force you to use one.
 
 Template engines simply can not match the performance of native PHP, and the syntax that must be learned to use a template
 engine is usually only marginally easier than learning the basics of PHP.  Consider this block of PHP code:</p>
@@ -147,13 +147,13 @@
 back into PHP to run. Since one of our goals is <em>maximum performance</em>, we opted to not require the use of a template engine.</p>
 
 
-<h2>Code Igniter is Thoroughly Documented</h2>
+<h2>CodeIgniter is Thoroughly Documented</h2>
 <p>Programmers love to code and hate to write documentation.  We're no different, of course, but
 since documentation is <strong>as important</strong> as the code itself,
 we are committed to doing it. Our source code is extremely clean and well commented as well.</p>
 
 
-<h2>Code Igniter has a Friendly Community of Users</h2>
+<h2>CodeIgniter has a Friendly Community of Users</h2>
 
 <p>Our growing community of users can be seen actively participating in our <a href="http://www.codeigniter.com/forums/">Community Forums</a>.</p>
 
@@ -168,10 +168,10 @@
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-Next Topic:&nbsp;&nbsp;<a href="features.html">Code Igniter Features</a>
+Next Topic:&nbsp;&nbsp;<a href="features.html">CodeIgniter Features</a>
 <p>
 
-<p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
+<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
 </div>
 
 </body>
diff --git a/user_guide/overview/features.html b/user_guide/overview/features.html
index afebeb7..d63821c 100644
--- a/user_guide/overview/features.html
+++ b/user_guide/overview/features.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>Code Igniter User Guide</title>
+<title>CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -22,7 +22,7 @@
 <meta http-equiv= 'pragma' content='no-cache' />
 <meta name='robots' content='all' />
 <meta name='author' content='Rick Ellis' />
-<meta name='description' content='Code Igniter User Guide' />
+<meta name='description' content='CodeIgniter User Guide' />
 
 </head>
 <body>
@@ -33,7 +33,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>Code Igniter User Guide Version 1.5.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 1.5.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -45,7 +45,7 @@
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
 <td id="breadcrumb">
-<a href="http://www.codeigniter.com/">Code Igniter Home</a> &nbsp;&#8250;&nbsp;
+<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
 <a href="../index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
 Features
 </td>
@@ -61,13 +61,13 @@
 <div id="content">
 
 
-<h1>Code Igniter Features</h1>
+<h1>CodeIgniter Features</h1>
 
 <p>Features in and of themselves are a very poor way to judge an application since they tell you nothing
 about the user experience, or how intuitively or intelligently it is designed.  Features
 don't reveal anything about the quality of the code, or the performance, or the attention to detail, or security practices.
 The only way to really judge an app is to try it and get to know the code. <a href="../installation/">Installing</a>
-Code Igniter is child's play so we encourage you to do just that.  In the mean time here's a list of Code Igniter's main features.</p>
+CodeIgniter is child's play so we encourage you to do just that.  In the mean time here's a list of CodeIgniter's main features.</p>
 
 <ul>
 <li>Model-View-Controller Based System</li>
@@ -112,14 +112,14 @@
 
 <div id="footer">
 <p>
-Previous Topic:&nbsp;&nbsp;<a href="at_a_glance.html">Code Igniter At a Glance</a>
+Previous Topic:&nbsp;&nbsp;<a href="at_a_glance.html">CodeIgniter At a Glance</a>
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 Next Topic:&nbsp;&nbsp;<a href="appflow.html">Application Flow Chart</a>
 <p>
 
-<p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
+<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
 </div>
 
 </body>
diff --git a/user_guide/overview/goals.html b/user_guide/overview/goals.html
index 07549ed..b531515 100644
--- a/user_guide/overview/goals.html
+++ b/user_guide/overview/goals.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>Code Igniter User Guide</title>
+<title>CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -22,7 +22,7 @@
 <meta http-equiv= 'pragma' content='no-cache' />
 <meta name='robots' content='all' />
 <meta name='author' content='Rick Ellis' />
-<meta name='description' content='Code Igniter User Guide' />
+<meta name='description' content='CodeIgniter User Guide' />
 
 </head>
 <body>
@@ -33,7 +33,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>Code Igniter User Guide Version 1.5.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 1.5.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -45,7 +45,7 @@
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
 <td id="breadcrumb">
-<a href="http://www.codeigniter.com/">Code Igniter Home</a> &nbsp;&#8250;&nbsp;
+<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
 <a href="../index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
 Goals
 </td>
@@ -64,20 +64,20 @@
 
 <h2>Design and Architectural Goals</h2>
 
-<p>Our goal for Code Igniter is <dfn>maximum performance, capability, and flexibility in the smallest, lightest possible package</dfn>.</p>
+<p>Our goal for CodeIgniter is <dfn>maximum performance, capability, and flexibility in the smallest, lightest possible package</dfn>.</p>
 
 <p>To meet this goal we are committed to benchmarking, re-factoring, and simplifying at every step of the development process,
 rejecting anything that doesn't further the stated objective.</p>
 
-<p>From an technical and architectural standpoint, Code Igniter was created with the following objectives:</p>
+<p>From an technical and architectural standpoint, CodeIgniter was created with the following objectives:</p>
 
 <ul>
-<li><strong>Dynamic Instantiation.</strong>  In Code Igniter, components are loaded and routines executed only when requested, rather than globally.  No assumptions are made by the system regarding what may be needed beyond the minimal core resources, so the system is very light-weight by default.  The events, as triggered by the HTTP request, and the controllers and views you design will determine what is invoked.</li>
+<li><strong>Dynamic Instantiation.</strong>  In CodeIgniter, components are loaded and routines executed only when requested, rather than globally.  No assumptions are made by the system regarding what may be needed beyond the minimal core resources, so the system is very light-weight by default.  The events, as triggered by the HTTP request, and the controllers and views you design will determine what is invoked.</li>
 <li><strong>Loose Coupling.</strong>  Coupling is the degree to which components of a system rely on each other.  The less components depend on each other the more reusable and flexible the system becomes. Our goal was a very loosely coupled system.</li>
-<li><strong>Component Singularity.</strong>  Singularity is the degree to which components have a narrowly focused purpose.  In Code Igniter, each class and its functions are highly autonomous in order to allow maximum usefulness.</li>
+<li><strong>Component Singularity.</strong>  Singularity is the degree to which components have a narrowly focused purpose.  In CodeIgniter, each class and its functions are highly autonomous in order to allow maximum usefulness.</li>
 </ul>
 
-<p>Code Igniter is a dynamically instantiated, loosely coupled system with high component singularity. It strives for simplicity, flexibility, and high performance in a small footprint package.</p>
+<p>CodeIgniter is a dynamically instantiated, loosely coupled system with high component singularity. It strives for simplicity, flexibility, and high performance in a small footprint package.</p>
 
 
 
@@ -96,7 +96,7 @@
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 Next Topic:&nbsp;&nbsp;<a href="../general/index.html">Getting Started</a>
 <p>
-<p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
+<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
 </div>
 
 </body>
diff --git a/user_guide/overview/index.html b/user_guide/overview/index.html
index e8d60f3..edd2293 100644
--- a/user_guide/overview/index.html
+++ b/user_guide/overview/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>Code Igniter User Guide</title>
+<title>CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -22,7 +22,7 @@
 <meta http-equiv= 'pragma' content='no-cache' />
 <meta name='robots' content='all' />
 <meta name='author' content='Rick Ellis' />
-<meta name='description' content='Code Igniter User Guide' />
+<meta name='description' content='CodeIgniter User Guide' />
 
 </head>
 <body>
@@ -33,7 +33,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>Code Igniter User Guide Version 1.5.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 1.5.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -45,7 +45,7 @@
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
 <td id="breadcrumb">
-<a href="http://www.codeigniter.com/">Code Igniter Home</a> &nbsp;&#8250;&nbsp;
+<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
 <a href="../index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
 Introduction
 </td>
@@ -60,12 +60,12 @@
 <!-- START CONTENT -->
 <div id="content">
 
-<h1>Code Igniter Overview</h1>
+<h1>CodeIgniter Overview</h1>
 
-<p>The following pages describe the broad concepts behind Code Igniter:</p>
+<p>The following pages describe the broad concepts behind CodeIgniter:</p>
 
 	<ul>
-		<li><a href="at_a_glance.html">Code Igniter at a Glance</a></li>
+		<li><a href="at_a_glance.html">CodeIgniter at a Glance</a></li>
 		<li><a href="features.html">Supported Features</a></li>
 		<li><a href="appflow.html">Application Flow Chart</a></li>
 		<li><a href="mvc.html">Introduction to the Model-View-Controller</a></li>
@@ -82,7 +82,7 @@
 
 <div id="footer">
 <p><a href="#top">Top of Page</a> &nbsp;&middot;&nbsp; <a href="../index.html">User Guide Home</a><p>
-<p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
+<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
 </div>
 
 </body>
diff --git a/user_guide/overview/mvc.html b/user_guide/overview/mvc.html
index c718ff5..f1ca19a 100644
--- a/user_guide/overview/mvc.html
+++ b/user_guide/overview/mvc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>Code Igniter User Guide</title>
+<title>CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -22,7 +22,7 @@
 <meta http-equiv= 'pragma' content='no-cache' />
 <meta name='robots' content='all' />
 <meta name='author' content='Rick Ellis' />
-<meta name='description' content='Code Igniter User Guide' />
+<meta name='description' content='CodeIgniter User Guide' />
 
 </head>
 <body>
@@ -33,7 +33,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>Code Igniter User Guide Version 1.5.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 1.5.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -45,7 +45,7 @@
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
 <td id="breadcrumb">
-<a href="http://www.codeigniter.com/">Code Igniter Home</a> &nbsp;&#8250;&nbsp;
+<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
 <a href="../index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
 MVC
 </td>
@@ -63,7 +63,7 @@
 
 <h1>Model-View-Controller</h1>
 
-<p>Code Igniter is based on the Model-View-Controller development pattern.
+<p>CodeIgniter is based on the Model-View-Controller development pattern.
 
 MVC is a software approach that separates application logic from presentation.  In practice, it permits your web pages to contain minimal scripting since the presentation is separate from the PHP scripting.</p>
 
@@ -71,15 +71,15 @@
 <li>The <strong>Model</strong> represents your data structures. Typically your model classes will contain functions that help you
 retrieve, insert, and update information in your your database.</li>
 <li>The <strong>View</strong> is the information that is being presented to a user.  A View will normally be a web page, but
-in Code Igniter, a view can also be a page fragment like a header or footer. It can also be an RSS page, or any other type of "page".</li>
+in CodeIgniter, a view can also be a page fragment like a header or footer. It can also be an RSS page, or any other type of "page".</li>
 <li>The <strong>Controller</strong> serves as an <em>intermediary</em> between the Model, the View,
 and any other resources needed to process the HTTP request and generate a web page.</li>
 
 </ul>
 
-<p>Code Igniter has a fairly loose approach to MVC since Models are not required.
+<p>CodeIgniter has a fairly loose approach to MVC since Models are not required.
 If you don't need the added separation, or find that maintaining models requires more complexity than you
-want, you can ignore them and build your application minimally using Controllers and Views. Code Igniter also
+want, you can ignore them and build your application minimally using Controllers and Views. CodeIgniter also
 enables you to incorporate your own existing scripts, or even develop core libraries for the system,
  enabling you to work in a way that makes the most sense to you.</p>
 
@@ -98,7 +98,7 @@
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 Next Topic:&nbsp;&nbsp;<a href="goals.html">Architectural Goals</a>
 <p>
-<p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
+<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
 </div>
 
 </body>
